package com.smartbus.bus.controller;

import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Date;
import java.text.SimpleDateFormat;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.smartbus.common.annotation.Log;
import com.smartbus.common.core.controller.BaseController;
import com.smartbus.common.core.domain.AjaxResult;
import com.smartbus.common.enums.BusinessType;
import com.smartbus.bus.domain.VoiceFiles;
import com.smartbus.bus.service.IVoiceFilesService;
import com.smartbus.bus.service.IBusStationsService;
import com.smartbus.bus.domain.BusStations;
import com.smartbus.common.utils.poi.ExcelUtil;
import com.smartbus.common.core.page.TableDataInfo;

/**
 * 语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件Controller
 * 
 * @author ruoyi
 * @date 2025-09-24
 */
@RestController
@RequestMapping("/bus/files")
public class VoiceFilesController extends BaseController
{
    @Autowired
    private IVoiceFilesService voiceFilesService;

    @Autowired
    private IBusStationsService busStationsService;

    @Autowired
    private HttpServletRequest request;

    /**
     * 转换文件路径为静态资源访问路径
     * @param filePath 相对文件路径，如：/voice/filename.mp3
     * @return 静态资源访问路径，如：/profile/upload/voice/filename.mp3
     */
    private String convertToStaticUrl(String filePath) {
        if (filePath == null || filePath.trim().isEmpty()) {
            return filePath;
        }

        // 如果已经是完整的静态资源路径，直接返回
        if (filePath.startsWith("/profile/")) {
            return filePath;
        }

        // 构建静态资源访问路径：/profile/upload + filePath
        // filePath 格式为 /voice/filename.mp3
        // 最终路径为 /profile/upload/voice/filename.mp3
        return "/profile/upload" + filePath;
    }

    /**
     * 填充语音文件的关联信息（站点名称和语音类型）
     */
    private void enrichVoiceFileInfo(VoiceFiles voiceFile) {
        // 填充站点名称
        if (voiceFile.getStationId() != null) {
            try {
                BusStations station = busStationsService.selectBusStationsById(voiceFile.getStationId());
                if (station != null) {
                    voiceFile.setStationName(station.getStationName());
                }
            } catch (Exception e) {
                logger.warn("获取站点名称失败，stationId: " + voiceFile.getStationId(), e);
                voiceFile.setStationName("未知站点");
            }
        }

        // 填充语音类型
        if (voiceFile.getAnnouncementTypeId() != null) {
            voiceFile.setAnnouncementType(mapAnnouncementTypeIdToCode(voiceFile.getAnnouncementTypeId()));
        }

        // 转换文件路径为静态资源访问路径
        String staticUrl = convertToStaticUrl(voiceFile.getFilePath());
        voiceFile.setFilePath(staticUrl);
    }

    /**
     * 将报站类型ID映射为代码
     */
    private String mapAnnouncementTypeIdToCode(Long typeId) {
        if (typeId == null) return "unknown";

        switch (typeId.intValue()) {
            case 1: return "next";      // 即将到站
            case 2: return "arrival";   // 已到达
            case 3: return "transfer";  // 换乘提示
            case 4: return "terminal";  // 终点站
            case 5: return "safety";    // 安全提示
            default: return "custom";   // 自定义
        }
    }

    /**
     * 查询语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件列表
     */
    @PreAuthorize("@ss.hasPermi('bus:files:list')")
    @GetMapping("/list")
    public TableDataInfo list(VoiceFiles voiceFiles)
    {
        startPage();
        List<VoiceFiles> list = voiceFilesService.selectVoiceFilesList(voiceFiles);

        // 填充关联信息（站点名称、语音类型、文件路径）
        list.forEach(this::enrichVoiceFileInfo);

        return getDataTable(list);
    }

    /**
     * 导出语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件列表
     */
    @PreAuthorize("@ss.hasPermi('bus:files:export')")
    @Log(title = "语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, VoiceFiles voiceFiles)
    {
        List<VoiceFiles> list = voiceFilesService.selectVoiceFilesList(voiceFiles);
        ExcelUtil<VoiceFiles> util = new ExcelUtil<VoiceFiles>(VoiceFiles.class);
        util.exportExcel(response, list, "语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件数据");
    }

    /**
     * 获取语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件详细信息
     */
    @PreAuthorize("@ss.hasPermi('bus:files:query')")
    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id)
    {
        VoiceFiles voiceFile = voiceFilesService.selectVoiceFilesById(id);
        if (voiceFile != null) {
            enrichVoiceFileInfo(voiceFile);
        }
        return success(voiceFile);
    }

    /**
     * 新增语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件
     */
    @PreAuthorize("@ss.hasPermi('bus:files:add')")
    @Log(title = "语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody VoiceFiles voiceFiles)
    {
        return toAjax(voiceFilesService.insertVoiceFiles(voiceFiles));
    }

    /**
     * 修改语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件
     */
    @PreAuthorize("@ss.hasPermi('bus:files:edit')")
    @Log(title = "语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody VoiceFiles voiceFiles)
    {
        return toAjax(voiceFilesService.updateVoiceFiles(voiceFiles));
    }

    /**
     * 删除语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件
     */
    @PreAuthorize("@ss.hasPermi('bus:files:remove')")
    @Log(title = "语音文件管理，存储TTS合成的各站点、各语言、各类型的报站语音文件", businessType = BusinessType.DELETE)
	@DeleteMapping("/{ids}")
    public AjaxResult remove(@PathVariable Long[] ids)
    {
        return toAjax(voiceFilesService.deleteVoiceFilesByIds(ids));
    }

    /**
     * 获取语音文件统计信息
     */
    @PreAuthorize("@ss.hasPermi('bus:files:list')")
    @GetMapping("/statistics")
    public AjaxResult getStatistics()
    {
        try {
            Map<String, Object> statistics = new HashMap<>();

            // 获取总文件数
            VoiceFiles queryAll = new VoiceFiles();
            queryAll.setIsActive(1);
            List<VoiceFiles> allFiles = voiceFilesService.selectVoiceFilesList(queryAll);
            statistics.put("totalFiles", allFiles.size());

            // 计算总文件大小
            long totalSize = allFiles.stream()
                .mapToLong(file -> file.getFileSize() != null ? file.getFileSize() : 0L)
                .sum();
            statistics.put("totalSize", formatFileSize(totalSize));

            // 获取今日生成的文件数
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            String today = sdf.format(new Date());
            int todayFiles = (int) allFiles.stream()
                .filter(file -> file.getCreatedAt() != null &&
                       sdf.format(file.getCreatedAt()).equals(today))
                .count();
            statistics.put("todayFiles", todayFiles);

            // 获取停用的文件数（模拟过期文件）
            VoiceFiles queryInactive = new VoiceFiles();
            queryInactive.setIsActive(0);
            List<VoiceFiles> inactiveFiles = voiceFilesService.selectVoiceFilesList(queryInactive);
            statistics.put("expiredFiles", inactiveFiles.size());

            return success(statistics);
        } catch (Exception e) {
            logger.error("获取语音文件统计信息失败：" + e.getMessage(), e);
            return error("获取统计信息失败");
        }
    }

    /**
     * 根据站点ID获取语音文件列表
     */
    @PreAuthorize("@ss.hasPermi('bus:files:list')")
    @GetMapping("/station/{stationId}")
    public AjaxResult getVoiceFilesByStation(@PathVariable Long stationId)
    {
        try {
            VoiceFiles query = new VoiceFiles();
            query.setStationId(stationId);
            query.setIsActive(1);
            List<VoiceFiles> list = voiceFilesService.selectVoiceFilesList(query);

            // 填充关联信息（站点名称、语音类型、文件路径）
            list.forEach(this::enrichVoiceFileInfo);

            return success(list);
        } catch (Exception e) {
            logger.error("获取站点语音文件失败：" + e.getMessage(), e);
            return error("获取站点语音文件失败");
        }
    }

    /**
     * 批量删除过期文件
     */
    @PreAuthorize("@ss.hasPermi('bus:files:remove')")
    @Log(title = "清理过期语音文件", businessType = BusinessType.DELETE)
    @PostMapping("/cleanup")
    public AjaxResult cleanupExpiredFiles(@RequestParam(defaultValue = "7") int days)
    {
        try {
            // 查找过期文件（这里简化为查找停用状态的文件）
            VoiceFiles query = new VoiceFiles();
            query.setIsActive(0);
            List<VoiceFiles> expiredFiles = voiceFilesService.selectVoiceFilesList(query);

            Long[] expiredIds = expiredFiles.stream()
                .map(VoiceFiles::getId)
                .toArray(Long[]::new);

            if (expiredIds.length > 0) {
                int result = voiceFilesService.deleteVoiceFilesByIds(expiredIds);
                return success("清理完成，共清理了" + result + "个过期文件");
            } else {
                return success("没有找到需要清理的过期文件");
            }
        } catch (Exception e) {
            logger.error("清理过期文件失败：" + e.getMessage(), e);
            return error("清理过期文件失败");
        }
    }

    /**
     * 格式化文件大小
     */
    private String formatFileSize(long bytes) {
        if (bytes == 0) return "0 B";
        String[] units = {"B", "KB", "MB", "GB"};
        int digitGroups = (int) (Math.log10(bytes) / Math.log10(1024));
        return String.format("%.2f %s", bytes / Math.pow(1024, digitGroups), units[digitGroups]);
    }
}
